package javaLearning.接口与继承;

import java.util.Random;
import java.util.concurrent.*;

/**
 * @author : K k
 * @date : 12:28 2020/8/16
 * 两个接口出现了相同的方法，一样重写一次，因为实现类的重写会覆盖全部。
 * 接口中可以写public default的方法声明，可以定义静态变量，实现静态方法。
 * 接口方法不能被private protected final修饰
 *
 * 方法重写特点：（与父类相关）
 * 在子类和父类中，出现了方法声明相同的情况
 * 子类的方法声明要和父类相同
 * 子类要重写的方法，方法的权限修饰符不能比父类更低（public 、protected  、default  、private 权限依次增加）
 * 父类私有的方法，子类不能进行方法重写
 *
 * 方法重载特点：
 *  指在同一个类中，多个方法名相同，他们的参数列表不同（个数不同，数据类型不同）
 */
public class implementDemo implements demo1,demo2 {
    @Override
    public void action()  {
        String x=demo1.x; //static
        String y=demo1.aa; //final
        System.out.println("我到底是谁");
    }

    @Override
    public void action1() {
    }

    @Override
    public void action2() {
        demo1.action3();
    }

    @Override
    public void action3() {
    }

    protected int action1(int a, int b){return 0;}

    short action1(int a,long b){return 0;}

    public static void main(String[] args) {
        String s="hello world";
//        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//        String s = br.readLine();
        /*try {
            //通过反射修改字符串
            Field value = String.class.getDeclaredField("value");
            value.setAccessible(true);
            char[] c=(char[])value.get(s);
            c[5]='s';
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }*/

       /* String v="hello";
        System.out.println(v.getClass().getClasses());
        v+="world";
        System.out.println(v.getClass().getClasses());*/
        ThreadFactory factory = Executors.defaultThreadFactory();
        StringBuilder sb=new StringBuilder("hh");
        BlockingQueue<Runnable> queue1=new LinkedBlockingDeque(4);
        ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(1,
                3,
                60,
                TimeUnit.SECONDS, queue1,factory,new ThreadPoolExecutor.DiscardPolicy());

        for (int i = 1; i <= 10; i++) {
            Thread r=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行线程"+ new Random().nextInt());
                }
            });
            poolExecutor.execute(r);
        }
        poolExecutor.shutdown();


    }
}
